\section{Platform}
\subsection{World description}
\frame{
The world in that we are going to work has two different types of aspects to model.
\begin{itemize}
	\item Independent to other players(terrain/physics)
	\item Players related
\end{itemize}

}
\frame{
\frametitle{World description}
Other players independent
\begin{itemize}
	\item<1-> Layers of the environment
		\begin{itemize}
		\item The sky, floor, water surface, underwater.
		\end{itemize}
	\item Physics
		\begin{itemize}
		\item The possibility of the actions are affected by the environment, like mountains, rivers, seas, etc.
		\end{itemize}
	\item Fog-of-war
		\begin{itemize}
		\item Different kinds, like not being able to see enemies or the orography of the undiscovered terrain or only see enemies in the vision range. 
		\end{itemize}
	\item Resources/needs
		\begin{itemize}
		\item Needs: To be able to construct there are some specific needs like
		having a concrete building or having a concrete quantity of a resource.
		\item Resources: In SpringRTS we have two kind of resources, metal (cames with map) and energy (provided by some buildings)
		\end{itemize}
\end{itemize}

}
\frame{
\frametitle{World description}
Other players related
\begin{itemize}
	\item<1-> Units
		\begin{itemize}
			\item Buildings
			\item Mobile
		\end{itemize}
	\item<2-> Weapon/Units Physics
		\begin{itemize}
			\item Limitations of weapons
			\item Friendly Fire
		\end{itemize}
	\item<3-> Relations
		\begin{itemize}
			\item Allies
			\item Teams
		\end{itemize}			
\end{itemize}
\note{
\scriptsize
Units\\
Buildings: structures that gives more option to the player 
			like the possibility to evolve or the ability of creating new units
			(barracks allow to create soldiers, etc.)\\
Mobile units: usually this kind of games has a vast option of \\
			different units, flying units (planes, helicopters), land units (tanks, soldiers),
			aquatic units (ships, sea animals), sub-aquatic units (submarines, squids).
\\
Weapon/units Physics\\
Limitations of the weapons: Many of this games try to appear as real as possible 
		(there are lots of hard gamers that are disposed to give very bad marks to a game 
		if a group of peasants are able to destroy a fortress). So is usual that new games 
		try to have a realistic treatment of the physics and not allowing to kill a flying 
		unit with a soldier that only have an sword.\\
Friendly fire: In some games there's the possibility to shot your own units or your allies
		units. Even that in the majority of the games your own units can be affected by the 
		effects  of a own bomb.


}
}
\subsection{Scenario definition}
\frame{
\frametitle{Scenario definition}
\begin{itemize}
	\item {\bf MOD description (XTA)} 
	\item {\bf General map information}
\end{itemize}
}

\frame{
\frametitle{MOD description (XTA)}
\begin{itemize}
	\item<1-> {Total Annihilation public version}
	\item<2-> {Role balanced} 
	\item<3-> {Game starts with a commander/constructor unit}
	\item<4-> {All constructors can make all buildings}
	\item<5-> {The commanders are also strong}
\end{itemize}
\note{
{\bf MOD:} Mods traditionally constitute alterations of a game that change the
way it works.  But in Spring RTS, this term refers to a game in its own right
that runs on the Spring engine.

{\bf Justification XTA:} For privacy and documentation found, we chose XTA, a
public version of the mod Total Annihilation.

{\bf Balanced:} Every unit has a role, and no unit has every role. Very few
units get truly obsolete as a game progresses.

{\bf game starting:} Each player starts the game with a commander unit, with
constructor functions.

{\bf constructors - all labs}, with few exceptions: This opens new tactics such
as two or more players can evolute technologically together and quickly.

{\bf strong commanders:} It allows to fight with them
}
}

\frame{
\frametitle{General map information}
\begin{itemize}
	\item<1-> {Relieve map, textures and colours} 
	\item<2-> {Resources settings}
	\item<3-> {Physics}
\end{itemize}

\note{
{\bf Textures and colours:} It is possible to define the terrain texture and all
colours of the map, including air and water colours, the sun position, etc.

{\bf Relief map:}  Defined by grayscale image. Where white areas are the tops of
mountains and black areas are the sea floor or the bottom of valleys.

{\bf Resouces settings:}
	\begin{itemize}
		\item {maximum amount of metal you will gain in 1 second from an area of
			metal.}
		\item {how much energy will produce the generators at each step.}
		\item {area that is harvested by metal extractors.}
	\end{itemize}

{\bf Physics:} It is possible to customize the physics of the world, like
gravity. That affects, for example, ballistcs and how far units fly after an
explosion.
}
}


\subsection{Interfacing and APIs}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\frame{
\frametitle{Events \& Callbacks}
\begin{itemize}
	\item<1-> {\bf Events} 
		
		Everything that happens in the game is an Event.
		\begin{itemize}
			\item Spring RTS sends events whenever the  world changes
			\item Our platform implements an interface called by Spring to
				notify the events.
		\end{itemize}

	\item<2-> {\bf Callbacks}
		
		This is the channel with which our AI communicates with the
		Spring RTS platform. Two main scenarios:
		\begin{itemize}
			\item Actions that don't change the world
			\item Actions that change the world
		\end{itemize}
\end{itemize}

\note{
The actions that not change the world are those that retrieve game info, like
unit definitions, game status, and the like.

For actions that change the world, we have to create an special object that
wraps the command, and send it through the callback.
}
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\frame{
\frametitle{Java API}
\begin{itemize}
	\item In ordern to interface with the Spring RTS to create our intelligent opponent, we should
		perform the following steps:
		\begin{itemize}
			\item<1-> Create the basic overlay for the AI
			\item<2-> Create the translation of the events to our agent model
			\item<3-> Develop all the Agents intelligence
		\end{itemize}
	\item<4-> All this functionality has to be packed into a .jar that is loaded by the Spring
		RTS platform.
\end{itemize}


\note{
The first step is the one that interfaces the platform to our Java
implementation.

The second step is the one that translates the events and actions to our
internal representation. For instance, we can ignore certain events, we could
map events to our internal representation or the other way round, high level
actions our agent use have to be decomposed into a set of low level events.

The agent implementation itself.
}
}
